////#include"test.h"
#define _CRT_SECURE_NO_WARNINGS 1
//
////int main()
////{
////	Queue q;
////	int k;
////	cin >> k;
////	queueindit(&q,k);
////	queuepush(&q, 1,k);
////	queuepush(&q, 2,k);
////	queuepush(&q, 3,k);
////	queuepush(&q, 4,k);
////	queuepush(&q, 5,k);
////	queuepush(&q, 6,k);
////	queuepush(&q, 7,k);
////	queuepush(&q, 8,k);
////	printf("%d\n", queuepop(&q));
////	printf("%d", front(&q,k));
////	return 0;
////}
//
//
//
////#include"test.h"
////#include<iostream>
////using namespace std;
////bool cmp(int a, int b)
////{
////	return a > b;
////}
////void test1()
////{
////	Heap ph;
////	Heapindit(&ph);
////	HeapPush(&ph, 10);
////	HeapPush(&ph, 20);
////	HeapPush(&ph, 1);
////	HeapPush(&ph, 12);
////	HeapPush(&ph, 19);
////	HeapPush(&ph, 110000);
////	HeapPush(&ph, 210000);
////	HeapPush(&ph, 2);
////	HeapPush(&ph, 3);
////	HeapPush(&ph, -1);
////	HeapPush(&ph, -9);
////	HeapPush(&ph, 100000);
////	HeapPush(&ph, 90000);
////	HeapPush(&ph, 15000);
////	/*for (int i = 0; i < ph._size; i++)
////	{
////		cout << ph.a[i] << ' ';
////	}*/
////	TestTok(&ph);
////}
////void TestTok(Heap*hp)
////{
////	int k = 5;
////	int* a = hp->a;
////	int n = hp->_size - 1;
////	PrintTopK(hp, n, k);
////}
////int main()
////{
////	test1();
////	return 0;
////}
//
//
//
//
////#include<stdio.h>
////int main()
////{
////	int n = 4;
////	int num[4][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16} };
////	for (int i = 0; i < n; i++)
////	{
////		for (int j = 0; j < n; j++)
////		{
////			printf("%d ", num[i][j]);
////		}
////		printf("\n");
////	}
////	printf("\n");
////	for (int i = 0; i <n; i++)
////	{
////		for (int j = 0; j <=i; j++)
////		{
////			int t = num[i][j];
////			num[i][j] = num[j][i];
////			num[j][i] = t;
////		}
////	}
////	for (int i = 0; i < n; i++)
////	{
////		for (int j = 0; j < n; j++)
////		{
////			printf("%d ", num[i][j]);
////		}
////		printf("\n");
////	}
////	return 0;
////}
//
////#include"test.h"
////int main()
////{
////	int k = 4;
////	MyCircularQueue *obj=myCircularQueueCreate(k);
////	myCircularQueueEnQueue(obj, 1);
////	myCircularQueueEnQueue(obj, 2);
////	myCircularQueueEnQueue(obj, 3);
////	myCircularQueueEnQueue(obj, 4);
////	myCircularQueueDeQueue(obj);
////	myCircularQueueDeQueue(obj);
////	myCircularQueueDeQueue(obj);
////	myCircularQueueDeQueue(obj);
////	if (myCircularQueueDeQueue(obj))
////	{
////		cout << "true";
////	}
////
////	return 0;
////}
//
//
//
//
//
////#include"test.h"
////int main()
////{
////	BTNode* nodeA = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeB = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeC = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeD = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeE = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeF = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeG = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeH = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeI = (BTNode*)malloc(sizeof(BTNode));
////	BTNode* nodeJ = (BTNode*)malloc(sizeof(BTNode));
////	nodeA->_data = 'A';
////	nodeB->_data = 'B';
////	nodeC->_data = 'C';
////	nodeD->_data = 'D';
////	nodeE->_data = 'E';
////	nodeF->_data = 'F';
////	nodeG->_data = 'G';
////	nodeH->_data = 'H';
////	nodeA->_left = nodeB;
////	nodeA->_right = nodeC;
////	nodeB->_left = nodeD;
////	nodeB->_right = nodeE;
////	nodeC->_left = nodeF;
////	nodeC->_right = nodeG;
////	nodeD->_left = nodeH;
////	nodeD->_right = NULL;
////	nodeH->_left = nodeH->_right = NULL;
////	nodeE->_left = nodeE->_right = NULL;
////	nodeF->_left = nodeF->_right = NULL;
////	nodeG->_left = nodeG->_right = NULL;
////	nodeD->_right = nodeI;
////	nodeI->_data = 'I';
////	nodeI->_left = nodeI->_right = NULL;
////	nodeJ->_data = 'J';
////	nodeH->_left = nodeJ;
////	nodeJ->_left = nodeJ->_right = NULL;
////	//BinaryTreePrevOrder(nodeA);
////	//int t=BinaryTreeLeafSize(nodeA);
////	//int t= BinaryTreeLevelKSize(nodeA, 3);
////	//int t = TreeHigh(nodeA);
////	//cout << t;
////	//BTNode* t = BinaryTreeFind(nodeA, 'J');
////	//cout << t->_data << endl;
////	//cout << nodeJ->_data;
////	int t =BinaryTreeSize(nodeA);
////	cout << t;
////	return 0;
////}
//
//
//
////#include<iostream>
////using namespace std;
////const int N = 310;
////int f[N][N];
////int s[N];
////int n;
////int main()
////{
////    std::ios::sync_with_stdio(false);
////    cin >> n;
////    for (int i = 1; i <= n; i++)cin >> s[i];
////    for (int i = 1; i <= n; i++)s[i] += s[i - 1];
////    for (int len = 2; len <= n; len++) for (int len = 2; len <= n; len++)
////    {
////        for (int i = 1; i + len - 1 <= n; i++)  for (int i = 1; i + len - 1 <= n; i++)
////        {
////            int l = i, r = i + len - 1;int l = i, r = i + len - 1;
////            f[l][r] = 1e9; f[l][r] = 1e9;
////            for (int k = l; k < r; k++)for (int k = 1; k < r; k++)
////            {
////                f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);  f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
////            }
////        }
////    }
////    cout << f[1][n];
////    return 0;
////}
//
//
////#include<iostream>
////using namespace std;
////const int N = 1010;
////int f[N][N];
////int n;
////int s[N];
////int main()
////{
////    std::ios::sync_with_stdio(false);
////    cin >> n;
////    for (int i = 1; i <= n; i++)cin >> s[i];
////    for (int i = 1; i <= n; i++)s[i] += s[i - 1];
////    for (int len = 2; len <= n; len++)
////    {
////        for (int i = 1; i + len - 1 <= n; i++)
////        {
////            int l = i, r = i + len - 1;
////            f[l][r] = 1e9;
////            for (int k = 1; k < r; k++)
////            {
////                f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
////            }
////        }
////    }
////    cout << f[1][n];
////    return 0;
////}
//
//
//#include<queue>
//#include<iostream>
//using namespace std;
//queue<int>q;
//int n, k;
//int num[100100];
//int q[10010];
//int main()
//{
//	std::ios::sync_with_stdio(false);
//	cin >> n >> k;
//	for (int i = 0; i < n; i++)
//	{
//		cin >> num[i];
//	}
//	in
//	for (int i = 0; i < n; i++)
//	{
//		
//		
//	}
//
//
//	return 0;
//}



//#include<iostream>
//using namespace std;
//const int N = 1000010;
//int q[N], a[N];
//int main()
//{
//	std::ios::sync_with_stdio(false);
//	int n, k;
//	cin >> n >> k;
//	for (int i = 0; i < n; i++)
//	{
//		cin >> a[i];
//	}
//	int hh = 0; int tt = -1;
	/*for (int i = 0; i < n; i++)
	{
		if (i - k + 1 > q[hh] && hh <= tt)
		{
			hh++;
		}
		while (a[q[tt]] >= a[i] && hh <= tt)
		{
			tt--;
		}
		q[++tt] = i;
		if (i >= k - 1)
		{
			cout << a[q[hh]] << ' ';
		}
	}
	cout << endl;
	hh = 0, tt = -1;
	for (int i = 0; i < n; i++)
	{
		if (i - k + 1 > q[hh] && hh <= tt)
		{
			hh++;
		}
		while (a[q[tt]] <= a[i] && hh <= tt)
		{
			tt--;
		}
		q[++tt] = i;
		if (i >= k - 1)
		{
			cout << a[q[hh]] << ' ';
		}
	}
	return 0;
}*/


// 





//#include<iostream>
//using namespace std;
//const int N = 10010;
//int num[N];
//int q[N];
//int n;
//int k;
//int main()
//{
//	cin>>n>>k;
//	for (int i = 0; i < n; i++)
//	{
//		cin>>num[i];
//	}
//	int hh = 0, tt = -1;
//	for (int i = 0; i < n; i++)
//	{
//		if (hh <= tt && i - k + 1 > q[hh])
//		{
//			hh++;
//		}
//		while (hh <= tt &&num[q[tt]] > num[i])
//		{
//			tt--;
//		}
//		q[++tt] = i;
//		if (i >= k - 1)
//		{
//			cout << num[q[hh]] << ' ';
//		}
//	}
//
//
//	return 0;
//}




//#include<iostream>
//using namespace std;
//int n;
//int num[10010];
//int main()
//{
//	cin >> n;
//	for (int i = 0; i < n; i++)
//	{
//		cin >> num[i];
//	}
//	for (int i = 0; i < n; i++)
//	{
//		for (int j = 0; j < i; j++)
//		{
//			if (num[i] > num[j])
//			{
//				int t = num[i];
//				num[i] = num[j];
//				num[j] = t;
//			}
//		}
//	}
//	for (int i = 0; i < n; i++)
//	{
//		cout << num[i]<<' ';
//	}
//	return 0;
//}


//#include<iostream>
//using namespace std;
//int n;
//int num[5];
//int main()
//{
//	cin >> n;
//	for (int i = 0; i < n; i++)
//	{
//		cin >> num[i];
//	}
//	int gap = 3;
//	for (int end = 0; end < gap; end++)
//	{
//		int tmp = num[end + gap];
//		int j = end;
//		while (j >= 0)
//		{
//			if (num[j] > tmp)
//			{
//				num[j + gap] = num[j];
//				j -= gap;
//			}
//			else
//			{
//				break;
//			}
//		}
//		num[j + gap] = tmp;
//	}
//	for (int i = 0; i < n; i++)
//	{
//		cout << num[i] << ' ';
//	}
//	return 0;
//}

 


#include<stdio.h>
int add(int a, int b)
{
	return a + b;
}
int main()
{
	int a;
	int b;
	scanf("%d %d", &a, &b);
	printf("%d", add(a, b));
	return 0;
}
